"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
// 创建一个长度为length的数组   里边的值用value填充
function createArray(length, value) {
    var result = [];
    for (var index = 0; index < length; index++) {
        result[index] = value;
    }
    return result;
}
var rest = createArray(3, 'smd');
console.log(rest); // [ 'smd', 'smd', 'smd' ]
/**
 * 如果想给createArray定义规范，输入的value是什么类型   返回值就是什么类型 就用到了泛型
 * 将以上函数做如下改造
 */
var a;
(function (a) {
    function createArray(length, value) {
        var result = [];
        for (var index = 0; index < length; index++) {
            result[index] = value;
        }
        return result;
    }
    var rest = createArray(2, 1);
    console.log(rest); // [ 1, 1 ]
})(a || (a = {}));
function sum() {
    var args = arguments;
    console.log(args);
}
sum(1, 2, 3);
// 泛型类
var MyArray = /** @class */ (function () {
    function MyArray() {
        this.list = [];
    }
    MyArray.prototype.add = function (value) {
        return this.list.push(value);
    };
    MyArray.prototype.get0Value = function () {
        return this.list[0];
    };
    return MyArray;
}());
var myarr = new MyArray();
myarr.add(1);
myarr.add(2);
console.log(myarr.get0Value()); // 1
// 泛型与new
function factory(type) {
    return new type();
}
var Person = /** @class */ (function () {
    function Person() {
    }
    return Person;
}());
var p = factory(Person);
console.log(p);
var sum1 = function (a, b) {
    return a;
};
var sum2 = function (a, b) {
    return a;
};
// let sum: Add = function <T>(a: T, b: T) {
//   return a+b // TODO
// }
sum2(1, 2);
var sum3 = function (a, b) {
    return a + b;
};
sum3(1, 2);
var sum4 = function (a, b) {
    return (a + b);
};
sum4(2, 1);
// 定义多个泛型
function swap(tuple) {
    return [tuple[1], tuple[0]];
}
console.log(swap(['smd', 18])); // [ 18, 'smd' ]
function logger(val) {
    // T类型可以通过继承接口的形式 来约束变量val存在length属性   但是ts中泛型的继承和类中的继承不同，ts中泛型的继承是指T类型要和父类只多不能少的属性，至于是不是父类的子类不做要求  这属于ts的兼容性
    console.log(val.length);
}
var c1 = { list: ['1'] };
var c2 = [2];
// Interface 与 type
